/*
十滴水游戏
*/
#include <windows.h>
#include <stdio.h>
#include<graphics.h>
#include<conio.h>
#include<math.h>
#include <stdlib.h>
#include <time.h>
#include <iostream>
#define height 800 
#define width 1300
#define time_distance 180//水滴每运动一格的时间
#define TIME 15//游戏停顿时间
#define MAX_LIST 22//最大表格长宽，含缓冲，实际(MAX_LIST-1)
clock_t start=0, now=0;//计时器，便于控制程序运行时间
int water_all_color = 1;//切换颜色
int rgb[10][3] = { { 0,0,0 },{50,165,50},{207,23,13},{137,36,216},{30,30,142},
	{0,0,0}, { 60,191,57 } ,{232,25,14},{153,41,242},{35,36,168} };//颜色数组前五个为填充后五个为边框
int rgb_now[3] = { 0,0,0 };//当前颜色
int game_random[5] = { 20,15,12,6,0 };//以一百为标准，里面是每个水滴数量的比例，1-4
int row = 7, column = 7;//行列
int max = 5;//水滴数量阈值
float distance = 0;//表格距离
int x_0 = 300, y_0 = 100;//初始位置
int x_1 = 900, y_1 = 700;
int x_mouse=0, y_mouse=0, n_mouse = 0,time_mouse = 0;//鼠标的坐标，是否获取，缓冲时间
int num_water_use = 0, num_water_accept = 0, num_water_begin = 10, currentValue = 0;;//水滴点击数，炸裂数，初始数，可用数
int num_water_I_begin = 0;//自定义水滴初始数
int scene = 1;//打开的界面的编号
int water_over = 0,ice_over = 0;//判断场上是否有水滴移动，是否有水滴
int j = 0;//没什么用的参数，主要判断函数是否退出
struct condition
{
	int color;//0代表空，1代表AC（绿色）,2代表WA（红色）,3代表RE（紫色）,4代表TL（蓝色）,
	int num;//数量,默认为0个
	int water_up[5];//是否有喷射水,[5]表示5种颜色
	int water_down[5];
	int water_left[5];
	int water_right[5];
};
condition game[MAX_LIST][MAX_LIST];//仅存储1-20
condition game_temp[MAX_LIST][MAX_LIST];//临时存储
void clock_sleep();//控制程序运行精确时间
int randombetween(int a, int b);//随机数
void color_next(int color);//球边界颜色设置
void game_begin();//初始化全都为0和行列
void input_game();//输入数据
void game_fuzhi(struct condition a[MAX_LIST][MAX_LIST], struct condition b[MAX_LIST][MAX_LIST]);//将结构体a复制到结构体b
void condition_water_num(int p);//更新固定水滴数量
void condition_water_update(int p);//更新运动水滴状态
void draw_ice(float x, float y, int row, int column, int color, int n_water);//绘制固定水滴
void draw_water(float x, float y, int row_0, int column_0, int j);//绘制运动水滴
void draw_line(float x, float y);//绘制网格线
void mouse();//检测鼠标左键坐标
void mouse_count();//根据鼠标坐标计算各种坐标
void mouse_water();//根据鼠标坐标增加水滴
void mouse_result_22();//自定义结局
void draw_scene_1();//第一个界面的绘制
void scene_1_mouse();//第一个界面的鼠标检测
void begin();//游戏内初始化总函数
void count(int p);//游戏内计算总函数
void play();//游玩过程的通用函数
void draw(int p);//游玩内绘制总函数
void bug();//超出边界警告
void drawCircleWithGrowingGreen(int cirx, int ciry, int cirradius, int filledHeight, float r_x);//绘制显示水滴数量的辅助函数
void draw_circle();//绘制显示水滴数量的函数
void game_over();//游戏结束
int main()
{
	initgraph(width, height);
	while (1)
	{
		//第二极界面难度调整
		mouse();
		mouse_count();
		draw_scene_1();
		if (scene == 2)
			play();//第三极界面开始游戏
	}
	_getch();
	return 0;
}
void clock_sleep()//控制程序运行精确时间
{
	static clock_t start = clock(); // 静态变量保持时间戳
	clock_t now = clock();

	// 计算经过的时间（毫秒）
	int elapsed = static_cast<int>(1000.0 * (now - start) / CLOCKS_PER_SEC);

	// 计算剩余时间
	int remaining = TIME - elapsed;

	// 如果剩余时间大于0，才进行休眠
	if (remaining > 0) {
		Sleep(remaining);
	}

	// 更新开始时间为当前时间
	start = clock();
}
int randombetween(int a, int b)//随机数
{
	int r = rand() % (b - a + 1) + a;
	return r;
}
void color_next(int color)//球边界颜色设置
{
	rgb_now[0] = rgb[color][0];
	rgb_now[1] = rgb[color][1];
	rgb_now[2] = rgb[color][2];
}
void game_begin()//初始化全都为0和行列
{
	for (int i = 0; i <= (MAX_LIST-1); i++)
	{
		for (int j = 0; j <= (MAX_LIST-1); j++)
		{
			game[i][j].color = 0;
			game[i][j].num = 0;
			for (int k = 0; k < 5; k++)
			{
				game[i][j].water_up[k] = 0;
				game[i][j].water_down[k] = 0;
				game[i][j].water_left[k] = 0;
				game[i][j].water_right[k] = 0;
			}
		}
	}
	num_water_use = 0;
	num_water_accept = 0;
	num_water_begin = num_water_I_begin;
	int p = row;
	if (column > row)
		p = column;
	distance = (float)(x_1 - x_0) / p;
}
void input_game()//输入数据
{
	//全部为绿色
	for (int i = 1; i <= row; i++)
	{
		for (int j = 1; j <= column; j++)
		{
			game[i][j].color = water_all_color;
		}
	}
	for (int i = 1; i <= row; i++)
	{
		for (int j = 1; j <= column; j++)
		{
			int p = randombetween(1, 100);
			if (p <= game_random[0])
				game[i][j].num = 1;
			else if (p <= game_random[0] + game_random[1])
				game[i][j].num = 2;
			else if (p <= game_random[0] + game_random[1] + game_random[2])
				game[i][j].num = 3;
			else if (p <= game_random[0] + game_random[1] + game_random[2] + game_random[3])
				game[i][j].num = 4;
			else if (p <= game_random[0] + game_random[1] + game_random[2] + game_random[3] + game_random[4])
				game[i][j].num = 5;
			else
				game[i][j].num = 0;
		}
	}

}
void game_fuzhi(struct condition a[MAX_LIST][MAX_LIST], struct condition b[MAX_LIST][MAX_LIST])//将结构体a复制到结构体b
{
	for (int i = 0; i <= row + 1; i++)
	{
		for (int j = 0; j <= column + 1; j++)
		{
			b[i][j].color = a[i][j].color;
			b[i][j].num = a[i][j].num;
			for (int k = 0; k < 5; k++)
			{
				b[i][j].water_up[k] = a[i][j].water_up[k];
				b[i][j].water_down[k] = a[i][j].water_down[k];
				b[i][j].water_left[k] = a[i][j].water_left[k];
				b[i][j].water_right[k] = a[i][j].water_right[k];
			}
		}
	}
}
void condition_water_num(int p)//更新固定水滴数量
{
	if (p == 0) {
		int t = 1;
		ice_over = 0;
		for (int i = 1; i <= row; i++)
		{
			for (int j = 1; j <= column; j++)
			{
				if (game[i][j].num >= max)
				{
					//可能添加奖励函数
					game[i][j].num = 0;
					int game_color = game[i][j].color;
					game[i][j].water_up[game_color] += t;
					game[i][j].water_down[game_color] += t;
					game[i][j].water_left[game_color] += t;
					game[i][j].water_right[game_color] += t;
					game[i][j].color = 0;
					num_water_accept++;
					water_over = 1;
				}
				if (game[i][j].num >= 1)
					ice_over = 1;
			}
		}
		currentValue = -num_water_use + num_water_begin + num_water_accept;
	}
}
void condition_water_update(int p)//更新运动水滴状态
{
	if (p == 0)
	{
		water_over = 0;
		game_fuzhi(game, game_temp);//复制game到game_temp
		for (int i = 1; i <= row; i++)
		{
			for (int j = 1; j <= column; j++)
			{
				for (int k = 0; k < 5; k++)
				{
					if (game[i][j].water_up[k] >= 1)
						//水向上，若上方有且颜色相同，则合并，否则向上喷射
					{
						water_over = 1;
						int num = game[i][j].water_up[k];//水滴数量
						game_temp[i][j].water_up[k] = 0;//水滴射出，当前位置清空
						if (0 != game[i - 1][j].color && game_temp[i - 1][j].num >= 1)
							game_temp[i - 1][j].num += num;
						else
							game_temp[i - 1][j].water_up[k] += num;
					}
					if (game[i][j].water_down[k] >= 1)
						//水向下，若下方有且颜色相同，则合并，否则向下喷射
					{
						water_over = 1;
						int num = game[i][j].water_down[k];//水滴数量
						game_temp[i][j].water_down[k] = 0;//水滴射出，当前位置清空
						if (0 != game[i + 1][j].color && game_temp[i + 1][j].num >= 1)
							game_temp[i + 1][j].num += num;
						else
							game_temp[i + 1][j].water_down[k] += num;
					}
					if (game[i][j].water_left[k] >= 1)
						//水向左，若左方有且颜色相同，则合并，否则向左喷射
					{
						water_over = 1;
						int num = game[i][j].water_left[k];//水滴数量
						game_temp[i][j].water_left[k] = 0;//水滴射出，当前位置清空
						if (0 != game[i][j - 1].color && game_temp[i][j - 1].num >= 1)
							game_temp[i][j - 1].num += num;
						else
							game_temp[i][j - 1].water_left[k] += num;
					}
					if (game[i][j].water_right[k] >= 1)
						//水向右，若右方有且颜色相同，则合并，否则向右喷射
					{
						water_over = 1;
						int num = game[i][j].water_right[k];//水滴数量
						game_temp[i][j].water_right[k] = 0;//水滴射出，当前位置清空
						if (0 != game[i][j + 1].color && game_temp[i][j + 1].num >= 1)
							game_temp[i][j + 1].num += num;
						else
							game_temp[i][j + 1].water_right[k] += num;
					}
				}
			}
		}
		game_fuzhi(game_temp, game);
	}
}
void draw_ice(float x, float y, int row, int column, int color, int n_water)//绘制固定水滴
{
	// 设置填充颜色和线条颜色
	color_next(color + 5);
	setfillcolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
	setlinecolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
	// 根据 n_water 的值绘制不同的圆
	if (n_water == 1) {
		// 绘制第一种圆，若干个
		fillcircle(x + 0.1 * distance / 2, y + 0.1 * distance / 2, 0.25 * distance / 2 + 0.05 * distance / 2);
		fillcircle(x - 0.6 * distance / 2, y - 0.2 * distance / 2, 0.08 * distance / 2 + 0.03 * distance / 2);
		fillcircle(x - 0.3 * distance / 2, y + 0.6 * distance / 2, 0.1 * distance / 2 + 0.05 * distance / 2);
	}
	else if (n_water == 2) {
		// 绘制第二种圆，若干个
		fillcircle(x, y, 0.4 * distance / 2 + 0.05 * distance / 2); // 大圆
		fillcircle(x + 0.5 * distance / 2, y + 0.5 * distance / 2, 0.2 * distance / 2 + 0.05 * distance / 2); // 小圆1
	}
	else if (n_water == 3) {
		// 绘制第三种圆，若干个
		fillcircle(x + 0.35 * distance / 2, y + 0.3 * distance / 2, 0.55 * distance / 2 + 0.05 * distance / 2);
		fillcircle(x - 0.35 * distance / 2, y + 0.1 * distance / 2, 0.3 * distance / 2 + 0.05 * distance / 2);
	}
	else if (n_water == 4) {
		// 绘制第四种圆，若干个
		fillcircle(x, y, 0.7 * distance / 2 + 0.05 * distance / 2);
	}
	color_next(color);
	setfillcolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
	setlinecolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
	// 根据 n_water 的值绘制不同的圆
	if (n_water == 1) {
		// 绘制第一种圆，若干个
		fillcircle(x + 0.1 * distance / 2, y + 0.1 * distance / 2, 0.25 * distance / 2);
		fillcircle(x - 0.6 * distance / 2, y - 0.2 * distance / 2, 0.08 * distance / 2);
		fillcircle(x - 0.3 * distance / 2, y + 0.6 * distance / 2, 0.1 * distance / 2);
	}
	else if (n_water == 2) {
		// 绘制第二种圆，若干个
		fillcircle(x, y, 0.4 * distance / 2); // 大圆
		fillcircle(x + 0.5 * distance / 2, y + 0.5 * distance / 2, 0.2 * distance / 2); // 小圆1
	}
	else if (n_water == 3) {
		// 绘制第三种圆，若干个
		fillcircle(x + 0.35 * distance / 2, y + 0.3 * distance / 2, 0.55 * distance / 2);
		fillcircle(x - 0.35 * distance / 2, y + 0.1 * distance / 2, 0.3 * distance / 2);
	}
	else if (n_water == 4) {
		// 绘制第四种圆，若干个
		fillcircle(x, y, 0.7 * distance / 2);
	}
	// 可以添加默认情况或者错误处理
}
void draw_water(float x, float y, int row_0, int column_0, int j)//绘制运动水滴
{
	//先统一用绿色
	//将距离平均分为20份，n_water代表两中心点距离份数
	//需要分别对上下左右四个方向进行发射
	//通过行列数组得到四个方向水滴的个数，不为0则绘制
	float y1 = 0, y2 = 0, x1 = 0, x2 = 0;
	for (int k = 0; k < 5; k++)
	{
		color_next(k + 5);
		setfillcolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
		setlinecolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
		float radius;
		float juli = (j - 5) * distance / 30;
		if (game[row_0][column_0].water_up[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_up[k] + 1) * distance * 0.01;
			if (row_0 > 1)
			{
				y1 = y - distance / 12 * j;
				fillcircle(x, y1, radius + 0.05 * distance / 2);
			}
			else if (row_0 == 1 && j <= 5)
			{
				y1 = y - distance / 12 * j;
				fillcircle(x, y1, radius + 0.05 * distance / 2);
			}
			else if (row_0 == 1 && j > 5)
			{
				y1 = y - distance / 2;
				radius = radius / 3 + 0.02 * distance / 2;
				fillcircle(x, y1 + radius + juli, radius);
				fillcircle(x + juli, y1 + radius, radius);
				fillcircle(x - juli, y1 + radius, radius);
				fillcircle(x + juli * 0.7, y1 + radius + juli * 0.7, radius);
				fillcircle(x - juli * 0.7, y1 + radius + juli * 0.7, radius);
			}
		}
		if (game[row_0][column_0].water_down[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_down[k] + 1) * distance * 0.01;
			if (row_0 < row)
			{
				y2 = y + distance / 12 * j;
				fillcircle(x, y2, radius + 0.05 * distance / 2);
			}
			else if (row_0 == row && j <= 5)
			{
				y2 = y + distance / 12 * j;
				fillcircle(x, y2, radius + 0.05 * distance / 2);
			}
			else if (row_0 == row && j > 5)
			{
				y2 = y + distance / 2;
				radius = radius / 3 + 0.02 * distance / 2;
				fillcircle(x, y2 - radius - juli, radius);
				fillcircle(x + juli, y2 - radius, radius);
				fillcircle(x - juli, y2 - radius, radius);
				fillcircle(x + juli * 0.7, y2 - radius - juli * 0.7, radius);
				fillcircle(x - juli * 0.7, y2 - radius - juli * 0.7, radius);
			}
		}if (game[row_0][column_0].water_left[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_left[k] + 1) * distance * 0.01;
			if (column_0 > 1)
			{
				x1 = x - distance / 12 * j;
				fillcircle(x1, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == 1 && j <= 5)
			{
				x1 = x - distance / 12 * j;
				fillcircle(x1, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == 1 && j > 5)
			{
				x1 = x - distance / 2;
				radius = radius / 3 + 0.02 * distance / 2;
				fillcircle(x1 + radius + juli, y, radius);
				fillcircle(x1 + radius, y + juli, radius);
				fillcircle(x1 + radius, y - juli, radius);
				fillcircle(x1 + radius + juli * 0.7, y + juli * 0.7, radius);
				fillcircle(x1 + radius + juli * 0.7, y - juli * 0.7, radius);
			}
		}
		if (game[row_0][column_0].water_right[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_right[k] + 1) * distance * 0.01;
			if (column_0 < column)
			{
				x2 = x + distance / 12 * j;
				fillcircle(x2, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == column && j <= 5)
			{
				x2 = x + distance / 12 * j;
				fillcircle(x2, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == column && j > 5)
			{
				x2 = x + distance / 2;
				radius = radius / 3 + 0.02 * distance / 2;
				fillcircle(x2 - radius - juli, y, radius);
				fillcircle(x2 - radius, y + juli, radius);
				fillcircle(x2 - radius, y - juli, radius);
				fillcircle(x2 - radius - juli * 0.7, y + juli * 0.7, radius);
				fillcircle(x2 - radius - juli * 0.7, y - juli * 0.7, radius);
			}
		}
		color_next(k);
		setfillcolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
		setlinecolor(RGB(rgb_now[0], rgb_now[1], rgb_now[2]));
		if (game[row_0][column_0].water_up[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_up[k] + 1) * distance * 0.01;
			if (row_0 > 1)
			{
				y1 = y - distance / 12 * j;
				fillcircle(x, y1, radius + 0.05 * distance / 2);
			}
			else if (row_0 == 1 && j <= 5)
			{
				y1 = y - distance / 12 * j;
				fillcircle(x, y1, radius + 0.05 * distance / 2);
			}
			else if (row_0 == 1 && j > 5)
			{
				y1 = y - distance / 2;
				radius = radius / 3;
				fillcircle(x, y1 + radius + juli, radius);
				fillcircle(x + juli, y1 + radius, radius);
				fillcircle(x - juli, y1 + radius, radius);
				fillcircle(x + juli * 0.7, y1 + radius + juli * 0.7, radius);
				fillcircle(x - juli * 0.7, y1 + radius + juli * 0.7, radius);
			}

		}  if (game[row_0][column_0].water_down[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_down[k] + 1) * distance * 0.01;
			if (row_0 < row)
			{
				y2 = y + distance / 12 * j;
				fillcircle(x, y2, radius + 0.05 * distance / 2);
			}
			else if (row_0 == row && j <= 5)
			{
				y2 = y + distance / 12 * j;
				fillcircle(x, y2, radius + 0.05 * distance / 2);
			}
			else if (row_0 == row && j > 5)
			{
				y2 = y + distance / 2;
				radius = radius / 3;
				fillcircle(x, y2 - radius - juli, radius);
				fillcircle(x + juli, y2 - radius, radius);
				fillcircle(x - juli, y2 - radius, radius);
				fillcircle(x + juli * 0.7, y2 - radius - juli * 0.7, radius);
				fillcircle(x - juli * 0.7, y2 - radius - juli * 0.7, radius);
			}
		}
		if (game[row_0][column_0].water_left[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_left[k] + 1) * distance * 0.01;
			if (column_0 > 1)
			{
				x1 = x - distance / 12 * j;
				fillcircle(x1, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == 1 && j <= 5)
			{
				x1 = x - distance / 12 * j;
				fillcircle(x1, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == 1 && j > 5)
			{
				x1 = x - distance / 2;
				radius = radius / 3 + 0.02 * distance / 2;
				fillcircle(x1 + radius + juli, y, radius);
				fillcircle(x1 + radius, y + juli, radius);
				fillcircle(x1 + radius, y - juli, radius);
				fillcircle(x1 + radius + juli * 0.7, y + juli * 0.7, radius);
				fillcircle(x1 + radius + juli * 0.7, y - juli * 0.7, radius);
			}
		}
		if (game[row_0][column_0].water_right[k] != 0)
		{
			radius = (2 * game[row_0][column_0].water_right[k] + 1) * distance * 0.01;
			if (column_0 < column)
			{
				x2 = x + distance / 12 * j;
				fillcircle(x2, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == column && j <= 5)
			{
				x2 = x + distance / 12 * j;
				fillcircle(x2, y, radius + 0.05 * distance / 2);
			}
			else if (column_0 == column && j > 5)
			{
				x2 = x + distance / 2;
				radius = radius / 3 + 0.02 * distance / 2;
				fillcircle(x2 - radius - juli, y, radius);
				fillcircle(x2 - radius, y + juli, radius);
				fillcircle(x2 - radius, y - juli, radius);
				fillcircle(x2 - radius - juli * 0.7, y + juli * 0.7, radius);
				fillcircle(x2 - radius - juli * 0.7, y - juli * 0.7, radius);
			}
		}
	}
}
void draw_line(float x, float y)//绘制网格线
{
	// 设置线条颜色为天蓝色
	setfillcolor(RGB(135, 206, 250)); // 使用RGB宏设置线条颜色为天蓝色
	setlinecolor(RGB(135, 206, 250)); // 使用RGB宏设置线条颜色为天蓝色
	// 计算正方形边长的一半，正方形的边长等于圆的直径
	float half_distance = distance / 2;
	// 绘制正方形的上下两条边，以确保正方形刚好框住圆
	// 上边：从圆的中心点向上到圆的顶部
	rectangle(x - half_distance - 0.2, y - half_distance + 0.2, x + half_distance + 0.2, y - half_distance - 0.2); // 上边
	// 下边：从圆的中心点向下到圆的底部
	rectangle(x - half_distance - 0.2, y + half_distance + 0.2, x + half_distance + 0.2, y + half_distance - 0.2); // 下边
	// 左边：从圆的中心点向左到圆的左侧
	rectangle(x - half_distance - 0.2, y - half_distance + 0.2, x - half_distance + 0.2, y + half_distance - 0.2); // 左边
	// 右边：从圆的中心点向右到圆的右侧
	rectangle(x + half_distance - 0.2, y - half_distance + 0.2, x + half_distance + 0.2, y + half_distance - 0.2); // 右边
}
void mouse() //检测鼠标左键坐标
{
	time_mouse -= TIME;
	if ((GetAsyncKeyState(VK_LBUTTON) & 0x8000) && time_mouse <= 0) {
		time_mouse = time_distance / TIME * 8;
		// 获取鼠标在屏幕上的位置
		POINT cursorPos;
		GetCursorPos(&cursorPos); // 获取屏幕坐标
		// 获取当前活动窗口的句柄
		HWND hwnd = GetForegroundWindow(); // 获取前景窗口句柄
		RECT windowRect;
		// 获取活动窗口的位置
		if (GetWindowRect(hwnd, &windowRect)) {
			// 计算相对窗口左上角的坐标
			x_mouse = cursorPos.x - windowRect.left; // 获取相对 x 坐标
			y_mouse = cursorPos.y - windowRect.top;  // 获取相对 y 坐标
			// 获取标题栏和边框的高度
			int titleBarHeight = GetSystemMetrics(SM_CYSIZEFRAME) + GetSystemMetrics(SM_CYCAPTION);
			// 减去标题栏和边框的高度
			y_mouse -= titleBarHeight; // 调整 y 坐标
			// 检查坐标是否在窗口客户区内
			if (x_mouse < 0 || y_mouse < 0 ||
				x_mouse >= windowRect.right - windowRect.left ||
				y_mouse >= windowRect.bottom - windowRect.top - titleBarHeight) {
				// 鼠标在窗口外，不进行任何处理
				n_mouse = 0; // 可以选择重置鼠标标记
			}
			else {
				n_mouse = 1; // 标记鼠标位置已获取
			}
		}
	}
}
void mouse_count()//根据鼠标坐标计算各种坐标
{
	if (n_mouse == 1)
	{
		n_mouse = 0;
		if (scene == 0)//自定义模式界面编号为0,初始界面
		{

		}
		else if (scene == 1)//自定义模式界面编号为1,自定义模式界面数值调整
		{
			scene_1_mouse();
		}
		else if (scene == 2)//自定义模式界面编号为2，自定义界面游玩
		{
			mouse_water();
		}
		else if (scene == 3)//自定义模式界面结局游戏结算界面1
		{
			mouse_result_22();
		}
	}
}
void mouse_water()//根据鼠标坐标增加水滴
{
	if (currentValue >= 1)
	{
		for (int k = 1; k <= row; k++)//y
		{
			for (int l = 1; l <= column; l++)//x
			{
				float x = distance * (l - 0.5) + x_0;//中心坐标
				float y = distance * (k - 0.5) + y_0;
				if (game[k][l].num >= 1) {
					if (x_mouse<x + distance/2 && x_mouse>x - distance/2)
					{
						if (y_mouse<y + distance/2 && y_mouse>y - distance/2)
						{
							game[k][l].num += 1;
							num_water_use++;
							break;
						}
					}
				}
			}
		}
	}
}
void mouse_result_22()//自定义结局
{
	if (x_mouse >= 460 && x_mouse <= 850 && y_mouse >= 430 && y_mouse <= 530)
	{
		j = 1;
		scene = 2;//重来
	}
	else if (x_mouse >= 1100 && y_mouse <= 75)
	{
		j = 1;
		scene = 3;//退出
	}
}
void draw_scene_1()//第一个界面的绘制
{
	int h_1 = 100;
	int h_2 = 260;
	int h_3 = 420;
	int h_4 = 600;//矩形上边缘
	int h_5 = 210;
	int w_1 = 200;
	int w_2 = 800;
	int len = 400;//矩形长
	BeginBatchDraw();
	cleardevice();
	fillrectangle(w_1 - 5, h_4 - 5, w_1 + len, h_4 + 100);//返回的矩形
	fillrectangle(w_2 - 5, h_4 - 5, w_2 + len, h_4 + 100);//确定的矩形
	fillrectangle(w_1 - 5, h_1, w_1 + len, h_1 + 80);//行数的矩形
	fillrectangle(w_1 - 5, h_2, w_1 + len, h_2 + 80);//列数的矩形
	fillrectangle(w_1 - 5, h_3, w_1 + len, h_3 + 80);//初始水滴数的矩形
	fillrectangle(w_2 - 5, h_1, w_2 + len, h_1 + 80);//密度的矩形
	fillrectangle(w_2 - 5, h_5 - 5, w_2 + len, h_5 + 290);//密度参数的矩形
	setcolor(BLACK);
	setbkcolor(WHITE);
	TCHAR s[40]; // 增加字符数组大小
	swprintf_s(s, _T("返回")); // 
	settextstyle(100, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_1 + 100, h_4, s); // 起点
	swprintf_s(s, _T("确认")); // 
	settextstyle(100, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_2 + 100, h_4, s); //
	swprintf_s(s, _T("行数：%2d + -"), row);//行数
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_1, h_1 + 20, s);
	swprintf_s(s, _T("列数：%2d + -"), column);//列数
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_1, h_2 + 20, s);
	swprintf_s(s, _T("初始水%2d + -"), num_water_begin);//初始水滴数
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_1, h_3 + 20, s);
	swprintf_s(s, _T("密度"));//密度
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_2 + 160, h_1 + 20, s);
	swprintf_s(s, _T("一滴概率：%.2f + -"), (float)game_random[0] / 100);//一滴概率
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_2, h_5, s);
	swprintf_s(s, _T("两滴概率：%.2f + -"), (float)game_random[1] / 100);//两滴概率
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_2, h_5 + 80, s);
	swprintf_s(s, _T("三滴概率：%.2f + -"), (float)game_random[2] / 100);//三滴概率
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_2, h_5 + 160, s);
	swprintf_s(s, _T("四滴概率：%.2f + -"), (float)game_random[3] / 100);//四滴概率
	settextstyle(40, 0, _T("宋体")); // 设置文本样式
	outtextxy(w_2, h_5 + 240, s);
	setbkcolor(BLACK);
	setfillcolor(RED);
	setfillcolor(WHITE);
	EndBatchDraw();
	Sleep(TIME);
}
void scene_1_mouse()//第一个界面的鼠标检测
{
	/*坐标点
	390,140;430,140
	390,300;430,300
	510,460;550,460
	1110,230;1150,230
	1110,310;1150,310
	1110,390;1150,390
	1110,470;1150,470
	边长为20
	*/
	int r = 10;
	if (x_mouse >= 396 - r && x_mouse <= 396 + r && y_mouse >= 140 - r && y_mouse <= 140 + r)//行+
	{
		if (row < (MAX_LIST - 2))
			row += 1;
		else
			bug();
	}
	else if (x_mouse >= 436 - r && x_mouse <= 436 + r && y_mouse >= 140 - r && y_mouse <= 140 + r)//行-
	{
		if (row > 1)
			row -= 1;
		else
			bug();
	}
	else if (x_mouse >= 396 - r && x_mouse <= 396 + r && y_mouse >= 300 - r && y_mouse <= 300 + r)//列+
	{
		if (column < (MAX_LIST - 2))
			column += 1;
		else
			bug();
	}
	else if (x_mouse >= 436 - r && x_mouse <= 436 + r && y_mouse >= 300 - r && y_mouse <= 300 + r)//列-
	{
		if (column > 1)
			column -= 1;
		else
			bug();
	}
	else if (x_mouse >= 396 - r && x_mouse <= 396 + r && y_mouse >= 460 - r && y_mouse <= 460 + r)//水滴初始+
	{
		num_water_begin += 1;
	}
	else if (x_mouse >= 436 - r && x_mouse <= 436 + r && y_mouse >= 460 - r && y_mouse <= 460 + r)//水滴初始-
	{
		if (num_water_begin > 1)
			num_water_begin -= 1;
		else
			bug();
	}
	else if (x_mouse >= 1116 - r && x_mouse <= 1116 + r && y_mouse >= 230 - r && y_mouse <= 230 + r)//密度1+
	{
		if (game_random[0] < 100 && game_random[0] + game_random[1] + game_random[2] + game_random[3] < 100)
			game_random[0] += 1;
		else
			bug();
	}
	else if (x_mouse >= 1156 - r && x_mouse <= 1156 + r && y_mouse >= 230 - r && y_mouse <= 230 + r)//密度1-
	{
		if (game_random[0] > 0)
			game_random[0] -= 1;
		else
			bug();
	}
	else if (x_mouse >= 1116 - r && x_mouse <= 1116 + r && y_mouse >= 310 - r && y_mouse <= 310 + r)//密度2+
	{
		if (game_random[1] < 100 && game_random[0] + game_random[1] + game_random[2] + game_random[3] < 100)
			game_random[1] += 1;
		else
			bug();
	}
	else if (x_mouse >= 1156 - r && x_mouse <= 1156 + r && y_mouse >= 310 - r && y_mouse <= 310 + r)//密度2-
	{
		if (game_random[1] > 0)
			game_random[1] -= 1;
		else
			bug();
	}
	else if (x_mouse >= 1116 - r && x_mouse <= 1116 + r && y_mouse >= 390 - r && y_mouse <= 390 + r)//密度3+
	{
		if (game_random[2] < 100 && game_random[0] + game_random[1] + game_random[2] + game_random[3] < 100)
			game_random[2] += 1;
		else
			bug();
	}
	else if (x_mouse >= 1156 - r && x_mouse <= 1156 + r && y_mouse >= 390 - r && y_mouse <= 390 + r)//密度3-
	{
		if (game_random[2] > 0)
			game_random[2] -= 1;
		else
			bug();
	}
	else if (x_mouse >= 1116 - r && x_mouse <= 1116 + r && y_mouse >= 470 - r && y_mouse <= 470 + r)//密度4+
	{
		if (game_random[3] < 100 && game_random[0] + game_random[1] + game_random[2] + game_random[3] < 100)
			game_random[3] += 1;
		else
			bug();
	}
	else if (x_mouse >= 1156 - r && x_mouse <= 1156 + r && y_mouse >= 470 - r && y_mouse <= 470 + r)//密度4-
	{
		if (game_random[3] > 0)
			game_random[3] -= 1;
		else
			bug();
	}
	else if (x_mouse >= 206 && x_mouse <= 606 && y_mouse >= 600 && y_mouse <= 700)
	{
		scene = 0;
		//重置游戏界面
	}
	else if (x_mouse >= 806 && x_mouse <= 1206 && y_mouse >= 600 && y_mouse <= 700)
	{
		scene = 2;
		//开始游戏
	}
	num_water_I_begin = num_water_begin;//水滴点击数
}
void begin()//游戏内初始化总函数
{
	srand(time(0));//随机数种子
	game_begin();
	input_game();
}
void count(int p)//游戏内计算总函数
{
	mouse();
	mouse_count();
	condition_water_update(p);
	condition_water_num(p);
}
void play()//游玩过程的通用函数
{
	for (j = 0; j == 0;) 
	{
		begin();
		for (int i = 0; j == 0; i++)
		{
			for (int p = 0; p < time_distance / TIME; p++)
			{
				count(p);//鼠标与计算
				draw(p);//绘制
				clock_sleep();//精确延时
			}
			game_over();//结局判断
		}
		if (scene == 2)//再来一次
		{
			j = 0;
			continue;
		}
		scene = 1;//运行结束后返回界面1即上级界面
	}
}
void draw(int p)//游玩内绘制总函数
{
	BeginBatchDraw();
	setbkcolor(BLACK);
	cleardevice();
	for (int k = 1; k <= row; k++)//行
	{
		for (int l = 1; l <= column; l++)//列
		{
			float x = distance * (l - 0.5) + x_0;
			float y = distance * (k - 0.5) + y_0;
			draw_ice(x, y, k, l, game[k][l].color, game[k][l].num);//画固定水
			draw_water(x, y, k, l, p);//画移动水
			draw_line(x, y);//画网格线
		}
	}
	draw_circle();//画水滴数量圆
	EndBatchDraw();
}
void bug()//超出边界警告
{
	BeginBatchDraw();
	printf("\a");
	setcolor(RED);
	TCHAR s[40]; // 增加字符数组大小
	swprintf_s(s, _T("超出边界！")); // 
	settextstyle(100, 0, _T("宋体")); // 设置文本样式
	outtextxy(width / 2 - 300, height / 2 - 100, s); // 
	setcolor(BLACK);
	EndBatchDraw();
	Sleep(TIME * 20);
}
void drawCircleWithGrowingGreen(int cirx, int ciry, int cirradius, int filledHeight, float r_x)//绘制显示水滴数量的辅助函数
{
	// 绘制圆的边界
	circle(cirx, ciry, cirradius);
	// 设置填充颜色为绿色
	setfillcolor(GREEN);
	setlinecolor(GREEN);
	setcolor(GREEN);
	// 计算填充的起始和结束y坐标
	int startY = ciry + cirradius; // 圆的底部y坐标
	int endY = startY - filledHeight; // 填充的结束y坐标
	// 使用 floodfill 填充内部
	//r_x = cirradius;
	line(cirx - r_x, endY, cirx + r_x, endY); // 绘制一条线，线在圆内，高度为endY,长度用三角函数计算
	floodfill(cirx, startY - 1, GREEN);
	//圆心坐标为1200,400
	//如果数字如8两个圆围起来了floodfill无法填充，则需额外手动填充
	if (currentValue == 13)
	{
		floodfill(cirx + MAX_LIST, ciry + 24, GREEN);
	}
	else if (currentValue == 16)
	{
		floodfill(cirx + MAX_LIST, ciry + 24, GREEN);
	}
}
void draw_circle()//绘制显示水滴数量的函数
{
	int cirx = 1100, ciry = 400; // 圆心坐标
	int cirradius = 160; // 圆的半径
	// 定义最大值
	int targetValue = 30; //最高水滴数
	int maxFilledHeight = 2 * cirradius; // 圆的最大填充高度
	// 格式化并显示水滴点击数
	setcolor(GREEN); // 设置文本颜色为绿色
	TCHAR v[40]; // 字符串数组，用于储存水滴数量
	settextstyle(100, 0, _T("宋体")); // 设置文本样式
	// 更新文本，保持直到达到阈值
	swprintf_s(v, _T("%d"), currentValue); // 格式化水滴数值字符串
	int textWidth = textwidth(v);//计算文本的宽度
	int textX = cirx - textWidth / 2; // 中心位置
	// 输出水滴数量的文本
	if (currentValue <= 17)
		outtextxy(textX, ciry - 50, v); // 显示水滴数量
	else if (currentValue >= 19)
		outtextxy(textX, ciry - 260, v);// 显示水滴数量
	circle(cirx, ciry, cirradius);
	// 计算填充比例
	float filledProportion = (float)currentValue / 30;
	if (filledProportion > 1) {
		filledProportion = 1;
	}
	int currentFilledHeight = (int)(maxFilledHeight * filledProportion); // 计算当前填充高度
	float sin_r = fabs(filledProportion * 2 - 1);//高度相对圆心对半径的比例
	float r_x = sqrt((1 - sin_r * sin_r)) * cirradius;
	// 绘制圆并填充绿色部分
	if (currentValue > 0)
		drawCircleWithGrowingGreen(cirx, ciry, cirradius, currentFilledHeight, r_x);
	// 当数字达到30时，保持圆被填满的状态，填满到最大
	setcolor(BLACK); // 复原
}
void game_over()//游戏结束
{
	if (scene == 2)
	{
		if (currentValue <= 0 && water_over == 0)
		{
			j = 0;
			scene = 3;
			// 定义并计算 "WA!" 文本
			setbkmode(1);
			TCHAR s1[40]; // 增加字符数组大小
			swprintf_s(s1, _T("WA!")); //
			settextstyle(300, 0, _T("宋体")); // 设置文本样式
			int textWidth1 = textwidth(s1); // 计算文本的宽度
			int textHeight1 = textheight(s1); // 计算文本的高度
			setcolor(RED);
			// 确保 s1 的中心字符居中
			outtextxy((width - textWidth1) / 2, height / 2 - textHeight1, s1);
			// 定义并计算 "不服再战" 文本
			TCHAR s2[40]; // 增加字符数组大小
			swprintf_s(s2, _T("不服再战"));
			settextstyle(100, 0, _T("宋体")); // 设置文本样式
			int textWidth2 = textwidth(s2); // 计算文本的宽度
			int textHeight2 = textheight(s2); // 计算文本的高度
			setcolor(YELLOW);
			// 确保 s2 的中心字符居中
			outtextxy((width - textWidth2) / 2-50, height / 3 * 2 - textHeight2, s2);
			// 定义并计算 "走此小道" 文本
			TCHAR s3[40]; // 增加字符数组大小
			swprintf_s(s3, _T("走此小道"));
			settextstyle(50, 0, _T("宋体")); // 设置文本样式
			int textWidth3 = textwidth(s3); // 计算文本的宽度
			int textHeight3 = textheight(s3); // 计算文本的高度
			// 确保 s3 的中心字符在 x * 3 / 4 处
			outtextxy(width - 200, 25, s3);
			while (j == 0)
			{
				mouse();
				mouse_count();
			}
			setbkmode(2);
		}
		if (ice_over == 0)
		{
			j = 0;
			scene = 3;
			// 定义并计算 "AC!" 文本
			setbkmode(1);
			TCHAR s1[40]; // 增加字符数组大小
			swprintf_s(s1, _T("AC!")); //
			settextstyle(250, 0, _T("宋体")); // 设置文本样式
			int textWidth1 = textwidth(s1); // 计算文本的宽度
			int textHeight1 = textheight(s1); // 计算文本的高度
			setcolor(GREEN);
			// 确保 s1 的中心字符居中
			outtextxy((width - textWidth1) / 2, height / 2 - textHeight1, s1);
			// 定义并计算 "再来一遍" 文本
			TCHAR s2[40]; // 增加字符数组大小
			swprintf_s(s2, _T("再来一遍"));
			settextstyle(100, 0, _T("宋体")); // 设置文本样式
			int textWidth2 = textwidth(s2); // 计算文本的宽度
			int textHeight2 = textheight(s2); // 计算文本的高度
			setcolor(YELLOW);
			// 确保 s2 的中心字符居中
			outtextxy((width - textWidth2) / 2 - 50, height / 3 * 2 - textHeight2, s2);
			// 定义并计算 "挑战其它" 文本
			TCHAR s3[40]; // 增加字符数组大小
			swprintf_s(s3, _T("挑战其它"));
			settextstyle(50, 0, _T("宋体")); // 设置文本样式
			int textWidth3 = textwidth(s3); // 计算文本的宽度
			int textHeight3 = textheight(s3); // 计算文本的高度
			// 确保 s3 的中心字符在 x * 3 / 4 处
			outtextxy(width - 200, 25, s3);
			while (j == 0)
			{
				mouse();
				mouse_count();
			}
			setbkmode(2);
		}
	}
}
